// Generated from ./tsl_MR.g4 by ANTLR 4.7.3-SNAPSHOT


import { ATN } from "antlr4ts/atn/ATN";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { NotNull } from "antlr4ts/Decorators";
import { NoViableAltException } from "antlr4ts/NoViableAltException";
import { Override } from "antlr4ts/Decorators";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
import { RecognitionException } from "antlr4ts/RecognitionException";
import { RuleContext } from "antlr4ts/RuleContext";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";

import * as Utils from "antlr4ts/misc/Utils";

import { tsl_MRListener } from "./tsl_MRListener";

export class tsl_MRParser extends Parser {
	public static readonly T__0 = 1;
	public static readonly T__1 = 2;
	public static readonly T__2 = 3;
	public static readonly T__3 = 4;
	public static readonly T__4 = 5;
	public static readonly T__5 = 6;
	public static readonly T__6 = 7;
	public static readonly T__7 = 8;
	public static readonly T__8 = 9;
	public static readonly T__9 = 10;
	public static readonly T__10 = 11;
	public static readonly T__11 = 12;
	public static readonly T__12 = 13;
	public static readonly T__13 = 14;
	public static readonly T__14 = 15;
	public static readonly T__15 = 16;
	public static readonly T__16 = 17;
	public static readonly T__17 = 18;
	public static readonly T__18 = 19;
	public static readonly T__19 = 20;
	public static readonly T__20 = 21;
	public static readonly T__21 = 22;
	public static readonly T__22 = 23;
	public static readonly T__23 = 24;
	public static readonly T__24 = 25;
	public static readonly T__25 = 26;
	public static readonly T__26 = 27;
	public static readonly T__27 = 28;
	public static readonly T__28 = 29;
	public static readonly T__29 = 30;
	public static readonly T__30 = 31;
	public static readonly T__31 = 32;
	public static readonly T__32 = 33;
	public static readonly T__33 = 34;
	public static readonly T__34 = 35;
	public static readonly T__35 = 36;
	public static readonly T__36 = 37;
	public static readonly T__37 = 38;
	public static readonly T__38 = 39;
	public static readonly T__39 = 40;
	public static readonly T__40 = 41;
	public static readonly T__41 = 42;
	public static readonly T__42 = 43;
	public static readonly T__43 = 44;
	public static readonly T__44 = 45;
	public static readonly T__45 = 46;
	public static readonly T__46 = 47;
	public static readonly T__47 = 48;
	public static readonly T__48 = 49;
	public static readonly T__49 = 50;
	public static readonly T__50 = 51;
	public static readonly T__51 = 52;
	public static readonly T__52 = 53;
	public static readonly T__53 = 54;
	public static readonly T__54 = 55;
	public static readonly T__55 = 56;
	public static readonly T__56 = 57;
	public static readonly T__57 = 58;
	public static readonly T__58 = 59;
	public static readonly T__59 = 60;
	public static readonly T__60 = 61;
	public static readonly T__61 = 62;
	public static readonly T__62 = 63;
	public static readonly T__63 = 64;
	public static readonly T__64 = 65;
	public static readonly T__65 = 66;
	public static readonly T__66 = 67;
	public static readonly T__67 = 68;
	public static readonly ELSE = 69;
	public static readonly THEN = 70;
	public static readonly LET = 71;
	public static readonly DOM = 72;
	public static readonly RAN = 73;
	public static readonly MIN = 74;
	public static readonly MAX = 75;
	public static readonly NUMBER = 76;
	public static readonly COMMENT = 77;
	public static readonly COLON = 78;
	public static readonly NAME = 79;
	public static readonly WHITESPACE = 80;
	public static readonly NEWLINE = 81;
	public static readonly STRING = 82;
	public static readonly UNKNOWN = 83;
	public static readonly RULE_tsl = 0;
	public static readonly RULE_parametersStatement = 1;
	public static readonly RULE_environmentStatement = 2;
	public static readonly RULE_outputStatement = 3;
	public static readonly RULE_colon = 4;
	public static readonly RULE_paragraphStatement = 5;
	public static readonly RULE_outparagraphStatement = 6;
	public static readonly RULE_lineStatement = 7;
	public static readonly RULE_variant = 8;
	public static readonly RULE_dataTypes = 9;
	public static readonly RULE_compare = 10;
	public static readonly RULE_comparisonOperator = 11;
	public static readonly RULE_expression = 12;
	public static readonly RULE_exp = 13;
	public static readonly RULE_constraint = 14;
	public static readonly RULE_ifStatement = 15;
	public static readonly RULE_propertyStatement = 16;
	public static readonly RULE_errorStatement = 17;
	public static readonly RULE_singleStatement = 18;
	public static readonly RULE_mrStat = 19;
	public static readonly RULE_spec = 20;
	public static readonly RULE_iteNumbers = 21;
	public static readonly RULE_iteSuite = 22;
	public static readonly RULE_iteRate = 23;
	public static readonly RULE_mrStatement = 24;
	public static readonly RULE_mr = 25;
	public static readonly RULE_input = 26;
	public static readonly RULE_output = 27;
	public static readonly RULE_in = 28;
	public static readonly RULE_inFollow = 29;
	public static readonly RULE_out = 30;
	public static readonly RULE_outFollow = 31;
	public static readonly RULE_relation = 32;
	public static readonly RULE_encoding_decl = 33;
	// tslint:disable:no-trailing-whitespace
	public static readonly ruleNames: string[] = [
		"tsl", "parametersStatement", "environmentStatement", "outputStatement", 
		"colon", "paragraphStatement", "outparagraphStatement", "lineStatement", 
		"variant", "dataTypes", "compare", "comparisonOperator", "expression", 
		"exp", "constraint", "ifStatement", "propertyStatement", "errorStatement", 
		"singleStatement", "mrStat", "spec", "iteNumbers", "iteSuite", "iteRate", 
		"mrStatement", "mr", "input", "output", "in", "inFollow", "out", "outFollow", 
		"relation", "encoding_decl",
	];

	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
		undefined, "'parameters'", "'environments'", "'output'", "'['", "','", 
		"']'", "'string'", "'int'", "'double'", "'boolean'", "'decimal'", "'float'", 
		"'duration'", "'dateTime'", "'date'", "'time'", "'gYearMonth'", "'gYear'", 
		"'gMonthDay'", "'gDay'", "'gMonth'", "'hexBinary'", "'base64Binary'", 
		"'anyURI'", "'QName'", "'NOTATION'", "'Z'", "'R'", "'N'", "'R+'", "'not'", 
		"'='", "'>'", "'<'", "'(-'", "'>='", "'<='", "'=='", "'subset'", "'Z+'", 
		"'sin'", "'('", "')'", "'+'", "'-'", "'*'", "'/'", "'%'", "'<<'", "'>>'", 
		"'if'", "'property'", "'error'", "'single'", "'MR_spec'", "'{'", "'}'", 
		"'iteNumbers'", "'iteSuite'", "'iteRate'", "'MR'", "'input'", "'follow-input'", 
		"'follow-output'", "'relation'", "'or'", "'and'", "';'", "'else'", "'then'", 
		"'let'", "'dom'", "'ran'", "'min'", "'max'", undefined, undefined, "':'",
	];
	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, "ELSE", 
		"THEN", "LET", "DOM", "RAN", "MIN", "MAX", "NUMBER", "COMMENT", "COLON", 
		"NAME", "WHITESPACE", "NEWLINE", "STRING", "UNKNOWN",
	];
	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(tsl_MRParser._LITERAL_NAMES, tsl_MRParser._SYMBOLIC_NAMES, []);

	// @Override
	// @NotNull
	public get vocabulary(): Vocabulary {
		return tsl_MRParser.VOCABULARY;
	}
	// tslint:enable:no-trailing-whitespace

	// @Override
	public get grammarFileName(): string { return "tsl_MR.g4"; }

	// @Override
	public get ruleNames(): string[] { return tsl_MRParser.ruleNames; }

	// @Override
	public get serializedATN(): string { return tsl_MRParser._serializedATN; }

	constructor(input: TokenStream) {
		super(input);
		this._interp = new ParserATNSimulator(tsl_MRParser._ATN, this);
	}
	// @RuleVersion(0)
	public tsl(): TslContext {
		let _localctx: TslContext = new TslContext(this._ctx, this.state);
		this.enterRule(_localctx, 0, tsl_MRParser.RULE_tsl);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 68;
			this.parametersStatement();
			this.state = 69;
			this.environmentStatement();
			this.state = 70;
			this.outputStatement();
			this.state = 72;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === tsl_MRParser.T__54) {
				{
				this.state = 71;
				this.mrStat();
				}
			}

			this.state = 74;
			this.match(tsl_MRParser.EOF);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public parametersStatement(): ParametersStatementContext {
		let _localctx: ParametersStatementContext = new ParametersStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 2, tsl_MRParser.RULE_parametersStatement);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 76;
			this.match(tsl_MRParser.T__0);
			this.state = 77;
			this.match(tsl_MRParser.COLON);
			this.state = 79;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 78;
				this.paragraphStatement();
				}
				}
				this.state = 81;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public environmentStatement(): EnvironmentStatementContext {
		let _localctx: EnvironmentStatementContext = new EnvironmentStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 4, tsl_MRParser.RULE_environmentStatement);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 83;
			this.match(tsl_MRParser.T__1);
			this.state = 84;
			this.match(tsl_MRParser.COLON);
			this.state = 86;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 85;
				this.paragraphStatement();
				}
				}
				this.state = 88;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public outputStatement(): OutputStatementContext {
		let _localctx: OutputStatementContext = new OutputStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 6, tsl_MRParser.RULE_outputStatement);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 90;
			this.match(tsl_MRParser.T__2);
			this.state = 91;
			this.match(tsl_MRParser.COLON);
			this.state = 93;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 92;
				this.outparagraphStatement();
				}
				}
				this.state = 95;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public colon(): ColonContext {
		let _localctx: ColonContext = new ColonContext(this._ctx, this.state);
		this.enterRule(_localctx, 8, tsl_MRParser.RULE_colon);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 97;
			this.match(tsl_MRParser.COLON);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public paragraphStatement(): ParagraphStatementContext {
		let _localctx: ParagraphStatementContext = new ParagraphStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 10, tsl_MRParser.RULE_paragraphStatement);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 99;
			this.match(tsl_MRParser.NAME);
			this.state = 100;
			this.match(tsl_MRParser.COLON);
			this.state = 102;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 101;
				this.lineStatement();
				}
				}
				this.state = 104;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << tsl_MRParser.T__6) | (1 << tsl_MRParser.T__7) | (1 << tsl_MRParser.T__8) | (1 << tsl_MRParser.T__9) | (1 << tsl_MRParser.T__10) | (1 << tsl_MRParser.T__11) | (1 << tsl_MRParser.T__12) | (1 << tsl_MRParser.T__13) | (1 << tsl_MRParser.T__14) | (1 << tsl_MRParser.T__15) | (1 << tsl_MRParser.T__16) | (1 << tsl_MRParser.T__17) | (1 << tsl_MRParser.T__18) | (1 << tsl_MRParser.T__19) | (1 << tsl_MRParser.T__20) | (1 << tsl_MRParser.T__21) | (1 << tsl_MRParser.T__22) | (1 << tsl_MRParser.T__23) | (1 << tsl_MRParser.T__24) | (1 << tsl_MRParser.T__25) | (1 << tsl_MRParser.T__26) | (1 << tsl_MRParser.T__27) | (1 << tsl_MRParser.T__28) | (1 << tsl_MRParser.T__29))) !== 0));
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public outparagraphStatement(): OutparagraphStatementContext {
		let _localctx: OutparagraphStatementContext = new OutparagraphStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 12, tsl_MRParser.RULE_outparagraphStatement);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 106;
			this.match(tsl_MRParser.NAME);
			this.state = 107;
			this.match(tsl_MRParser.COLON);
			this.state = 109;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 108;
				this.lineStatement();
				}
				}
				this.state = 111;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << tsl_MRParser.T__6) | (1 << tsl_MRParser.T__7) | (1 << tsl_MRParser.T__8) | (1 << tsl_MRParser.T__9) | (1 << tsl_MRParser.T__10) | (1 << tsl_MRParser.T__11) | (1 << tsl_MRParser.T__12) | (1 << tsl_MRParser.T__13) | (1 << tsl_MRParser.T__14) | (1 << tsl_MRParser.T__15) | (1 << tsl_MRParser.T__16) | (1 << tsl_MRParser.T__17) | (1 << tsl_MRParser.T__18) | (1 << tsl_MRParser.T__19) | (1 << tsl_MRParser.T__20) | (1 << tsl_MRParser.T__21) | (1 << tsl_MRParser.T__22) | (1 << tsl_MRParser.T__23) | (1 << tsl_MRParser.T__24) | (1 << tsl_MRParser.T__25) | (1 << tsl_MRParser.T__26) | (1 << tsl_MRParser.T__27) | (1 << tsl_MRParser.T__28) | (1 << tsl_MRParser.T__29))) !== 0));
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public lineStatement(): LineStatementContext {
		let _localctx: LineStatementContext = new LineStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 14, tsl_MRParser.RULE_lineStatement);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 113;
			this.variant();
			this.state = 117;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === tsl_MRParser.T__3) {
				{
				{
				this.state = 114;
				this.constraint();
				}
				}
				this.state = 119;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public variant(): VariantContext {
		let _localctx: VariantContext = new VariantContext(this._ctx, this.state);
		this.enterRule(_localctx, 16, tsl_MRParser.RULE_variant);
		let _la: number;
		try {
			this.state = 136;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 9, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 120;
				this.dataTypes();
				this.state = 121;
				this.compare();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 123;
				this.dataTypes();
				this.state = 124;
				this.match(tsl_MRParser.NAME);
				this.state = 125;
				this.match(tsl_MRParser.T__3);
				this.state = 130;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 126;
					this.compare();
					this.state = 128;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === tsl_MRParser.T__4) {
						{
						this.state = 127;
						this.match(tsl_MRParser.T__4);
						}
					}

					}
					}
					this.state = 132;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === tsl_MRParser.NAME);
				this.state = 134;
				this.match(tsl_MRParser.T__5);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dataTypes(): DataTypesContext {
		let _localctx: DataTypesContext = new DataTypesContext(this._ctx, this.state);
		this.enterRule(_localctx, 18, tsl_MRParser.RULE_dataTypes);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 138;
			_la = this._input.LA(1);
			if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << tsl_MRParser.T__6) | (1 << tsl_MRParser.T__7) | (1 << tsl_MRParser.T__8) | (1 << tsl_MRParser.T__9) | (1 << tsl_MRParser.T__10) | (1 << tsl_MRParser.T__11) | (1 << tsl_MRParser.T__12) | (1 << tsl_MRParser.T__13) | (1 << tsl_MRParser.T__14) | (1 << tsl_MRParser.T__15) | (1 << tsl_MRParser.T__16) | (1 << tsl_MRParser.T__17) | (1 << tsl_MRParser.T__18) | (1 << tsl_MRParser.T__19) | (1 << tsl_MRParser.T__20) | (1 << tsl_MRParser.T__21) | (1 << tsl_MRParser.T__22) | (1 << tsl_MRParser.T__23) | (1 << tsl_MRParser.T__24) | (1 << tsl_MRParser.T__25) | (1 << tsl_MRParser.T__26) | (1 << tsl_MRParser.T__27) | (1 << tsl_MRParser.T__28) | (1 << tsl_MRParser.T__29))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public compare(): CompareContext {
		let _localctx: CompareContext = new CompareContext(this._ctx, this.state);
		this.enterRule(_localctx, 20, tsl_MRParser.RULE_compare);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 140;
			this.match(tsl_MRParser.NAME);
			this.state = 147;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (((((_la - 31)) & ~0x1F) === 0 && ((1 << (_la - 31)) & ((1 << (tsl_MRParser.T__30 - 31)) | (1 << (tsl_MRParser.T__31 - 31)) | (1 << (tsl_MRParser.T__32 - 31)) | (1 << (tsl_MRParser.T__33 - 31)) | (1 << (tsl_MRParser.T__34 - 31)) | (1 << (tsl_MRParser.T__35 - 31)) | (1 << (tsl_MRParser.T__36 - 31)) | (1 << (tsl_MRParser.T__37 - 31)) | (1 << (tsl_MRParser.T__38 - 31)))) !== 0)) {
				{
				this.state = 142;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === tsl_MRParser.T__30) {
					{
					this.state = 141;
					this.match(tsl_MRParser.T__30);
					}
				}

				this.state = 144;
				this.comparisonOperator();
				this.state = 145;
				this.expression();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public comparisonOperator(): ComparisonOperatorContext {
		let _localctx: ComparisonOperatorContext = new ComparisonOperatorContext(this._ctx, this.state);
		this.enterRule(_localctx, 22, tsl_MRParser.RULE_comparisonOperator);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 149;
			_la = this._input.LA(1);
			if (!(((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (tsl_MRParser.T__31 - 32)) | (1 << (tsl_MRParser.T__32 - 32)) | (1 << (tsl_MRParser.T__33 - 32)) | (1 << (tsl_MRParser.T__34 - 32)) | (1 << (tsl_MRParser.T__35 - 32)) | (1 << (tsl_MRParser.T__36 - 32)) | (1 << (tsl_MRParser.T__37 - 32)) | (1 << (tsl_MRParser.T__38 - 32)))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expression(): ExpressionContext {
		let _localctx: ExpressionContext = new ExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 24, tsl_MRParser.RULE_expression);
		let _la: number;
		try {
			this.state = 186;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case tsl_MRParser.T__26:
			case tsl_MRParser.T__27:
			case tsl_MRParser.T__28:
			case tsl_MRParser.T__39:
			case tsl_MRParser.NUMBER:
			case tsl_MRParser.NAME:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 151;
				_la = this._input.LA(1);
				if (!(((((_la - 27)) & ~0x1F) === 0 && ((1 << (_la - 27)) & ((1 << (tsl_MRParser.T__26 - 27)) | (1 << (tsl_MRParser.T__27 - 27)) | (1 << (tsl_MRParser.T__28 - 27)) | (1 << (tsl_MRParser.T__39 - 27)))) !== 0) || _la === tsl_MRParser.NUMBER || _la === tsl_MRParser.NAME)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 157;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (((((_la - 44)) & ~0x1F) === 0 && ((1 << (_la - 44)) & ((1 << (tsl_MRParser.T__43 - 44)) | (1 << (tsl_MRParser.T__44 - 44)) | (1 << (tsl_MRParser.T__45 - 44)) | (1 << (tsl_MRParser.T__46 - 44)) | (1 << (tsl_MRParser.T__47 - 44)) | (1 << (tsl_MRParser.T__48 - 44)) | (1 << (tsl_MRParser.T__49 - 44)))) !== 0)) {
					{
					{
					this.state = 152;
					this.exp();
					this.state = 153;
					_la = this._input.LA(1);
					if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << tsl_MRParser.T__26) | (1 << tsl_MRParser.T__27) | (1 << tsl_MRParser.T__28) | (1 << tsl_MRParser.T__29))) !== 0) || _la === tsl_MRParser.NUMBER || _la === tsl_MRParser.NAME)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					}
					}
					this.state = 159;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;
			case tsl_MRParser.T__40:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 160;
				this.match(tsl_MRParser.T__40);
				this.state = 161;
				this.match(tsl_MRParser.T__41);
				this.state = 162;
				this.match(tsl_MRParser.NAME);
				this.state = 163;
				this.match(tsl_MRParser.T__42);
				}
				break;
			case tsl_MRParser.MIN:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 164;
				this.match(tsl_MRParser.MIN);
				this.state = 165;
				this.match(tsl_MRParser.T__41);
				this.state = 170;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 166;
					this.match(tsl_MRParser.NAME);
					this.state = 168;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === tsl_MRParser.T__4) {
						{
						this.state = 167;
						this.match(tsl_MRParser.T__4);
						}
					}

					}
					}
					this.state = 172;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === tsl_MRParser.NAME);
				this.state = 174;
				this.match(tsl_MRParser.T__42);
				}
				break;
			case tsl_MRParser.MAX:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 175;
				this.match(tsl_MRParser.MAX);
				this.state = 176;
				this.match(tsl_MRParser.T__41);
				this.state = 181;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 177;
					this.match(tsl_MRParser.NAME);
					this.state = 179;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === tsl_MRParser.T__4) {
						{
						this.state = 178;
						this.match(tsl_MRParser.T__4);
						}
					}

					}
					}
					this.state = 183;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === tsl_MRParser.NAME);
				this.state = 185;
				this.match(tsl_MRParser.T__42);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public exp(): ExpContext {
		let _localctx: ExpContext = new ExpContext(this._ctx, this.state);
		this.enterRule(_localctx, 26, tsl_MRParser.RULE_exp);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 188;
			_la = this._input.LA(1);
			if (!(((((_la - 44)) & ~0x1F) === 0 && ((1 << (_la - 44)) & ((1 << (tsl_MRParser.T__43 - 44)) | (1 << (tsl_MRParser.T__44 - 44)) | (1 << (tsl_MRParser.T__45 - 44)) | (1 << (tsl_MRParser.T__46 - 44)) | (1 << (tsl_MRParser.T__47 - 44)) | (1 << (tsl_MRParser.T__48 - 44)) | (1 << (tsl_MRParser.T__49 - 44)))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public constraint(): ConstraintContext {
		let _localctx: ConstraintContext = new ConstraintContext(this._ctx, this.state);
		this.enterRule(_localctx, 28, tsl_MRParser.RULE_constraint);
		try {
			this.state = 194;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 18, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 190;
				this.ifStatement();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 191;
				this.propertyStatement();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 192;
				this.errorStatement();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 193;
				this.singleStatement();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ifStatement(): IfStatementContext {
		let _localctx: IfStatementContext = new IfStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 30, tsl_MRParser.RULE_ifStatement);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 196;
			this.match(tsl_MRParser.T__3);
			this.state = 197;
			this.match(tsl_MRParser.T__50);
			this.state = 198;
			this.match(tsl_MRParser.NAME);
			this.state = 199;
			this.match(tsl_MRParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public propertyStatement(): PropertyStatementContext {
		let _localctx: PropertyStatementContext = new PropertyStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 32, tsl_MRParser.RULE_propertyStatement);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 201;
			this.match(tsl_MRParser.T__3);
			this.state = 202;
			this.match(tsl_MRParser.T__51);
			this.state = 203;
			this.match(tsl_MRParser.NAME);
			this.state = 204;
			this.match(tsl_MRParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public errorStatement(): ErrorStatementContext {
		let _localctx: ErrorStatementContext = new ErrorStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 34, tsl_MRParser.RULE_errorStatement);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 206;
			this.match(tsl_MRParser.T__3);
			this.state = 207;
			this.match(tsl_MRParser.T__52);
			this.state = 208;
			this.match(tsl_MRParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public singleStatement(): SingleStatementContext {
		let _localctx: SingleStatementContext = new SingleStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 36, tsl_MRParser.RULE_singleStatement);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 210;
			this.match(tsl_MRParser.T__3);
			this.state = 211;
			this.match(tsl_MRParser.T__53);
			this.state = 212;
			this.match(tsl_MRParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public mrStat(): MrStatContext {
		let _localctx: MrStatContext = new MrStatContext(this._ctx, this.state);
		this.enterRule(_localctx, 38, tsl_MRParser.RULE_mrStat);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 214;
			this.spec();
			this.state = 216;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === tsl_MRParser.T__57) {
				{
				this.state = 215;
				this.iteNumbers();
				}
			}

			this.state = 219;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === tsl_MRParser.T__58) {
				{
				this.state = 218;
				this.iteSuite();
				}
			}

			this.state = 222;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === tsl_MRParser.T__59) {
				{
				this.state = 221;
				this.iteRate();
				}
			}

			this.state = 225;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 224;
				this.mrStatement();
				}
				}
				this.state = 227;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.T__60);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public spec(): SpecContext {
		let _localctx: SpecContext = new SpecContext(this._ctx, this.state);
		this.enterRule(_localctx, 40, tsl_MRParser.RULE_spec);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 229;
			this.match(tsl_MRParser.T__54);
			this.state = 230;
			this.match(tsl_MRParser.COLON);
			this.state = 231;
			this.match(tsl_MRParser.T__55);
			this.state = 236;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 232;
				this.match(tsl_MRParser.NAME);
				this.state = 234;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === tsl_MRParser.T__4) {
					{
					this.state = 233;
					this.match(tsl_MRParser.T__4);
					}
				}

				}
				}
				this.state = 238;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			this.state = 240;
			this.match(tsl_MRParser.T__56);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public iteNumbers(): IteNumbersContext {
		let _localctx: IteNumbersContext = new IteNumbersContext(this._ctx, this.state);
		this.enterRule(_localctx, 42, tsl_MRParser.RULE_iteNumbers);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 242;
			this.match(tsl_MRParser.T__57);
			this.state = 243;
			this.match(tsl_MRParser.COLON);
			this.state = 244;
			this.match(tsl_MRParser.NUMBER);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public iteSuite(): IteSuiteContext {
		let _localctx: IteSuiteContext = new IteSuiteContext(this._ctx, this.state);
		this.enterRule(_localctx, 44, tsl_MRParser.RULE_iteSuite);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 246;
			this.match(tsl_MRParser.T__58);
			this.state = 247;
			this.match(tsl_MRParser.COLON);
			this.state = 248;
			this.match(tsl_MRParser.NUMBER);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public iteRate(): IteRateContext {
		let _localctx: IteRateContext = new IteRateContext(this._ctx, this.state);
		this.enterRule(_localctx, 46, tsl_MRParser.RULE_iteRate);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 250;
			this.match(tsl_MRParser.T__59);
			this.state = 251;
			this.match(tsl_MRParser.COLON);
			this.state = 252;
			this.match(tsl_MRParser.NUMBER);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public mrStatement(): MrStatementContext {
		let _localctx: MrStatementContext = new MrStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 48, tsl_MRParser.RULE_mrStatement);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 254;
			this.match(tsl_MRParser.T__60);
			this.state = 255;
			this.match(tsl_MRParser.NAME);
			this.state = 256;
			this.colon();
			this.state = 257;
			this.mr();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public mr(): MrContext {
		let _localctx: MrContext = new MrContext(this._ctx, this.state);
		this.enterRule(_localctx, 50, tsl_MRParser.RULE_mr);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 259;
			this.input();
			this.state = 260;
			this.output();
			this.state = 261;
			this.relation();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public input(): InputContext {
		let _localctx: InputContext = new InputContext(this._ctx, this.state);
		this.enterRule(_localctx, 52, tsl_MRParser.RULE_input);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 263;
			this.in();
			this.state = 264;
			this.inFollow();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public output(): OutputContext {
		let _localctx: OutputContext = new OutputContext(this._ctx, this.state);
		this.enterRule(_localctx, 54, tsl_MRParser.RULE_output);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 266;
			this.out();
			this.state = 267;
			this.outFollow();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public in(): InContext {
		let _localctx: InContext = new InContext(this._ctx, this.state);
		this.enterRule(_localctx, 56, tsl_MRParser.RULE_in);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 269;
			this.match(tsl_MRParser.T__61);
			this.state = 270;
			this.colon();
			this.state = 271;
			this.match(tsl_MRParser.T__3);
			this.state = 276;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 272;
				this.match(tsl_MRParser.NAME);
				this.state = 274;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === tsl_MRParser.T__4) {
					{
					this.state = 273;
					this.match(tsl_MRParser.T__4);
					}
				}

				}
				}
				this.state = 278;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			this.state = 280;
			this.match(tsl_MRParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public inFollow(): InFollowContext {
		let _localctx: InFollowContext = new InFollowContext(this._ctx, this.state);
		this.enterRule(_localctx, 58, tsl_MRParser.RULE_inFollow);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 282;
			this.match(tsl_MRParser.T__62);
			this.state = 283;
			this.colon();
			this.state = 284;
			this.match(tsl_MRParser.T__3);
			this.state = 289;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 285;
				this.compare();
				this.state = 287;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === tsl_MRParser.T__4) {
					{
					this.state = 286;
					this.match(tsl_MRParser.T__4);
					}
				}

				}
				}
				this.state = 291;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			this.state = 293;
			this.match(tsl_MRParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public out(): OutContext {
		let _localctx: OutContext = new OutContext(this._ctx, this.state);
		this.enterRule(_localctx, 60, tsl_MRParser.RULE_out);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 295;
			this.match(tsl_MRParser.T__2);
			this.state = 296;
			this.colon();
			this.state = 297;
			this.match(tsl_MRParser.T__3);
			this.state = 302;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 298;
				this.match(tsl_MRParser.NAME);
				this.state = 300;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === tsl_MRParser.T__4) {
					{
					this.state = 299;
					this.match(tsl_MRParser.T__4);
					}
				}

				}
				}
				this.state = 304;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			this.state = 306;
			this.match(tsl_MRParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public outFollow(): OutFollowContext {
		let _localctx: OutFollowContext = new OutFollowContext(this._ctx, this.state);
		this.enterRule(_localctx, 62, tsl_MRParser.RULE_outFollow);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 308;
			this.match(tsl_MRParser.T__63);
			this.state = 309;
			this.colon();
			this.state = 310;
			this.match(tsl_MRParser.T__3);
			this.state = 315;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 311;
				this.compare();
				this.state = 313;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === tsl_MRParser.T__4) {
					{
					this.state = 312;
					this.match(tsl_MRParser.T__4);
					}
				}

				}
				}
				this.state = 317;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			this.state = 319;
			this.match(tsl_MRParser.T__5);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public relation(): RelationContext {
		let _localctx: RelationContext = new RelationContext(this._ctx, this.state);
		this.enterRule(_localctx, 64, tsl_MRParser.RULE_relation);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 321;
			this.match(tsl_MRParser.T__64);
			this.state = 322;
			this.colon();
			this.state = 333;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 327;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 323;
					this.compare();
					this.state = 325;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === tsl_MRParser.T__65 || _la === tsl_MRParser.T__66) {
						{
						this.state = 324;
						_la = this._input.LA(1);
						if (!(_la === tsl_MRParser.T__65 || _la === tsl_MRParser.T__66)) {
						this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						}
					}

					}
					}
					this.state = 329;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === tsl_MRParser.NAME);
				this.state = 331;
				this.match(tsl_MRParser.T__67);
				}
				}
				this.state = 335;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while (_la === tsl_MRParser.NAME);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public encoding_decl(): Encoding_declContext {
		let _localctx: Encoding_declContext = new Encoding_declContext(this._ctx, this.state);
		this.enterRule(_localctx, 66, tsl_MRParser.RULE_encoding_decl);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 337;
			this.match(tsl_MRParser.NAME);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public static readonly _serializedATN: string =
		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03U\u0156\x04\x02" +
		"\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
		"\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
		"\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04" +
		"\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17\x04" +
		"\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C\t\x1C\x04" +
		"\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x04\"\t\"\x04#" +
		"\t#\x03\x02\x03\x02\x03\x02\x03\x02\x05\x02K\n\x02\x03\x02\x03\x02\x03" +
		"\x03\x03\x03\x03\x03\x06\x03R\n\x03\r\x03\x0E\x03S\x03\x04\x03\x04\x03" +
		"\x04\x06\x04Y\n\x04\r\x04\x0E\x04Z\x03\x05\x03\x05\x03\x05\x06\x05`\n" +
		"\x05\r\x05\x0E\x05a\x03\x06\x03\x06\x03\x07\x03\x07\x03\x07\x06\x07i\n" +
		"\x07\r\x07\x0E\x07j\x03\b\x03\b\x03\b\x06\bp\n\b\r\b\x0E\bq\x03\t\x03" +
		"\t\x07\tv\n\t\f\t\x0E\ty\v\t\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n" +
		"\x03\n\x05\n\x83\n\n\x06\n\x85\n\n\r\n\x0E\n\x86\x03\n\x03\n\x05\n\x8B" +
		"\n\n\x03\v\x03\v\x03\f\x03\f\x05\f\x91\n\f\x03\f\x03\f\x03\f\x05\f\x96" +
		"\n\f\x03\r\x03\r\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x07\x0E\x9E\n\x0E\f\x0E" +
		"\x0E\x0E\xA1\v\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03" +
		"\x0E\x03\x0E\x05\x0E\xAB\n\x0E\x06\x0E\xAD\n\x0E\r\x0E\x0E\x0E\xAE\x03" +
		"\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x05\x0E\xB6\n\x0E\x06\x0E\xB8\n\x0E" +
		"\r\x0E\x0E\x0E\xB9\x03\x0E\x05\x0E\xBD\n\x0E\x03\x0F\x03\x0F\x03\x10\x03" +
		"\x10\x03\x10\x03\x10\x05\x10\xC5\n\x10\x03\x11\x03\x11\x03\x11\x03\x11" +
		"\x03\x11\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x03\x13\x03\x13\x03\x13" +
		"\x03\x13\x03\x14\x03\x14\x03\x14\x03\x14\x03\x15\x03\x15\x05\x15\xDB\n" +
		"\x15\x03\x15\x05\x15\xDE\n\x15\x03\x15\x05\x15\xE1\n\x15\x03\x15\x06\x15" +
		"\xE4\n\x15\r\x15\x0E\x15\xE5\x03\x16\x03\x16\x03\x16\x03\x16\x03\x16\x05" +
		"\x16\xED\n\x16\x06\x16\xEF\n\x16\r\x16\x0E\x16\xF0\x03\x16\x03\x16\x03" +
		"\x17\x03\x17\x03\x17\x03\x17\x03\x18\x03\x18\x03\x18\x03\x18\x03\x19\x03" +
		"\x19\x03\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03" +
		"\x1B\x03\x1B\x03\x1B\x03\x1C\x03\x1C\x03\x1C\x03\x1D\x03\x1D\x03\x1D\x03" +
		"\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x05\x1E\u0115\n\x1E\x06\x1E\u0117" +
		"\n\x1E\r\x1E\x0E\x1E\u0118\x03\x1E\x03\x1E\x03\x1F\x03\x1F\x03\x1F\x03" +
		"\x1F\x03\x1F\x05\x1F\u0122\n\x1F\x06\x1F\u0124\n\x1F\r\x1F\x0E\x1F\u0125" +
		"\x03\x1F\x03\x1F\x03 \x03 \x03 \x03 \x03 \x05 \u012F\n \x06 \u0131\n " +
		"\r \x0E \u0132\x03 \x03 \x03!\x03!\x03!\x03!\x03!\x05!\u013C\n!\x06!\u013E" +
		"\n!\r!\x0E!\u013F\x03!\x03!\x03\"\x03\"\x03\"\x03\"\x05\"\u0148\n\"\x06" +
		"\"\u014A\n\"\r\"\x0E\"\u014B\x03\"\x03\"\x06\"\u0150\n\"\r\"\x0E\"\u0151" +
		"\x03#\x03#\x03#\x02\x02\x02$\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02" +
		"\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02" +
		" \x02\"\x02$\x02&\x02(\x02*\x02,\x02.\x020\x022\x024\x026\x028\x02:\x02" +
		"<\x02>\x02@\x02B\x02D\x02\x02\b\x03\x02\t \x03\x02\")\x06\x02\x1D\x1F" +
		"**NNQQ\x05\x02\x1D NNQQ\x03\x02.4\x03\x02DE\x02\u015B\x02F\x03\x02\x02" +
		"\x02\x04N\x03\x02\x02\x02\x06U\x03\x02\x02\x02\b\\\x03\x02\x02\x02\nc" +
		"\x03\x02\x02\x02\fe\x03\x02\x02\x02\x0El\x03\x02\x02\x02\x10s\x03\x02" +
		"\x02\x02\x12\x8A\x03\x02\x02\x02\x14\x8C\x03\x02\x02\x02\x16\x8E\x03\x02" +
		"\x02\x02\x18\x97\x03\x02\x02\x02\x1A\xBC\x03\x02\x02\x02\x1C\xBE\x03\x02" +
		"\x02\x02\x1E\xC4\x03\x02\x02\x02 \xC6\x03\x02\x02\x02\"\xCB\x03\x02\x02" +
		"\x02$\xD0\x03\x02\x02\x02&\xD4\x03\x02\x02\x02(\xD8\x03\x02\x02\x02*\xE7" +
		"\x03\x02\x02\x02,\xF4\x03\x02\x02\x02.\xF8\x03\x02\x02\x020\xFC\x03\x02" +
		"\x02\x022\u0100\x03\x02\x02\x024\u0105\x03\x02\x02\x026\u0109\x03\x02" +
		"\x02\x028\u010C\x03\x02\x02\x02:\u010F\x03\x02\x02\x02<\u011C\x03\x02" +
		"\x02\x02>\u0129\x03\x02\x02\x02@\u0136\x03\x02\x02\x02B\u0143\x03\x02" +
		"\x02\x02D\u0153\x03\x02\x02\x02FG\x05\x04\x03\x02GH\x05\x06\x04\x02HJ" +
		"\x05\b\x05\x02IK\x05(\x15\x02JI\x03\x02\x02\x02JK\x03\x02\x02\x02KL\x03" +
		"\x02\x02\x02LM\x07\x02\x02\x03M\x03\x03\x02\x02\x02NO\x07\x03\x02\x02" +
		"OQ\x07P\x02\x02PR\x05\f\x07\x02QP\x03\x02\x02\x02RS\x03\x02\x02\x02SQ" +
		"\x03\x02\x02\x02ST\x03\x02\x02\x02T\x05\x03\x02\x02\x02UV\x07\x04\x02" +
		"\x02VX\x07P\x02\x02WY\x05\f\x07\x02XW\x03\x02\x02\x02YZ\x03\x02\x02\x02" +
		"ZX\x03\x02\x02\x02Z[\x03\x02\x02\x02[\x07\x03\x02\x02\x02\\]\x07\x05\x02" +
		"\x02]_\x07P\x02\x02^`\x05\x0E\b\x02_^\x03\x02\x02\x02`a\x03\x02\x02\x02" +
		"a_\x03\x02\x02\x02ab\x03\x02\x02\x02b\t\x03\x02\x02\x02cd\x07P\x02\x02" +
		"d\v\x03\x02\x02\x02ef\x07Q\x02\x02fh\x07P\x02\x02gi\x05\x10\t\x02hg\x03" +
		"\x02\x02\x02ij\x03\x02\x02\x02jh\x03\x02\x02\x02jk\x03\x02\x02\x02k\r" +
		"\x03\x02\x02\x02lm\x07Q\x02\x02mo\x07P\x02\x02np\x05\x10\t\x02on\x03\x02" +
		"\x02\x02pq\x03\x02\x02\x02qo\x03\x02\x02\x02qr\x03\x02\x02\x02r\x0F\x03" +
		"\x02\x02\x02sw\x05\x12\n\x02tv\x05\x1E\x10\x02ut\x03\x02\x02\x02vy\x03" +
		"\x02\x02\x02wu\x03\x02\x02\x02wx\x03\x02\x02\x02x\x11\x03\x02\x02\x02" +
		"yw\x03\x02\x02\x02z{\x05\x14\v\x02{|\x05\x16\f\x02|\x8B\x03\x02\x02\x02" +
		"}~\x05\x14\v\x02~\x7F\x07Q\x02\x02\x7F\x84\x07\x06\x02\x02\x80\x82\x05" +
		"\x16\f\x02\x81\x83\x07\x07\x02\x02\x82\x81\x03\x02\x02\x02\x82\x83\x03" +
		"\x02\x02\x02\x83\x85\x03\x02\x02\x02\x84\x80\x03\x02\x02\x02\x85\x86\x03" +
		"\x02\x02\x02\x86\x84\x03\x02\x02\x02\x86\x87\x03\x02\x02\x02\x87\x88\x03" +
		"\x02\x02\x02\x88\x89\x07\b\x02\x02\x89\x8B\x03\x02\x02\x02\x8Az\x03\x02" +
		"\x02\x02\x8A}\x03\x02\x02\x02\x8B\x13\x03\x02\x02\x02\x8C\x8D\t\x02\x02" +
		"\x02\x8D\x15\x03\x02\x02\x02\x8E\x95\x07Q\x02\x02\x8F\x91\x07!\x02\x02" +
		"\x90\x8F\x03\x02\x02\x02\x90\x91\x03\x02\x02\x02\x91\x92\x03\x02\x02\x02" +
		"\x92\x93\x05\x18\r\x02\x93\x94\x05\x1A\x0E\x02\x94\x96\x03\x02\x02\x02" +
		"\x95\x90\x03\x02\x02\x02\x95\x96\x03\x02\x02\x02\x96\x17\x03\x02\x02\x02" +
		"\x97\x98\t\x03\x02\x02\x98\x19\x03\x02\x02\x02\x99\x9F\t\x04\x02\x02\x9A" +
		"\x9B\x05\x1C\x0F\x02\x9B\x9C\t\x05\x02\x02\x9C\x9E\x03\x02\x02\x02\x9D" +
		"\x9A\x03\x02\x02\x02\x9E\xA1\x03\x02\x02\x02\x9F\x9D\x03\x02\x02\x02\x9F" +
		"\xA0\x03\x02\x02\x02\xA0\xBD\x03\x02\x02\x02\xA1\x9F\x03\x02\x02\x02\xA2" +
		"\xA3\x07+\x02\x02\xA3\xA4\x07,\x02\x02\xA4\xA5\x07Q\x02\x02\xA5\xBD\x07" +
		"-\x02\x02\xA6\xA7\x07L\x02\x02\xA7\xAC\x07,\x02\x02\xA8\xAA\x07Q\x02\x02" +
		"\xA9\xAB\x07\x07\x02\x02\xAA\xA9\x03\x02\x02\x02\xAA\xAB\x03\x02\x02\x02" +
		"\xAB\xAD\x03\x02\x02\x02\xAC\xA8\x03\x02\x02\x02\xAD\xAE\x03\x02\x02\x02" +
		"\xAE\xAC\x03\x02\x02\x02\xAE\xAF\x03\x02\x02\x02\xAF\xB0\x03\x02\x02\x02" +
		"\xB0\xBD\x07-\x02\x02\xB1\xB2\x07M\x02\x02\xB2\xB7\x07,\x02\x02\xB3\xB5" +
		"\x07Q\x02\x02\xB4\xB6\x07\x07\x02\x02\xB5\xB4\x03\x02\x02\x02\xB5\xB6" +
		"\x03\x02\x02\x02\xB6\xB8\x03\x02\x02\x02\xB7\xB3\x03\x02\x02\x02\xB8\xB9" +
		"\x03\x02\x02\x02\xB9\xB7\x03\x02\x02\x02\xB9\xBA\x03\x02\x02\x02\xBA\xBB" +
		"\x03\x02\x02\x02\xBB\xBD\x07-\x02\x02\xBC\x99\x03\x02\x02\x02\xBC\xA2" +
		"\x03\x02\x02\x02\xBC\xA6\x03\x02\x02\x02\xBC\xB1\x03\x02\x02\x02\xBD\x1B" +
		"\x03\x02\x02\x02\xBE\xBF\t\x06\x02\x02\xBF\x1D\x03\x02\x02\x02\xC0\xC5" +
		"\x05 \x11\x02\xC1\xC5\x05\"\x12\x02\xC2\xC5\x05$\x13\x02\xC3\xC5\x05&" +
		"\x14\x02\xC4\xC0\x03\x02\x02\x02\xC4\xC1\x03\x02\x02\x02\xC4\xC2\x03\x02" +
		"\x02\x02\xC4\xC3\x03\x02\x02\x02\xC5\x1F\x03\x02\x02\x02\xC6\xC7\x07\x06" +
		"\x02\x02\xC7\xC8\x075\x02\x02\xC8\xC9\x07Q\x02\x02\xC9\xCA\x07\b\x02\x02" +
		"\xCA!\x03\x02\x02\x02\xCB\xCC\x07\x06\x02\x02\xCC\xCD\x076\x02\x02\xCD" +
		"\xCE\x07Q\x02\x02\xCE\xCF\x07\b\x02\x02\xCF#\x03\x02\x02\x02\xD0\xD1\x07" +
		"\x06\x02\x02\xD1\xD2\x077\x02\x02\xD2\xD3\x07\b\x02\x02\xD3%\x03\x02\x02" +
		"\x02\xD4\xD5\x07\x06\x02\x02\xD5\xD6\x078\x02\x02\xD6\xD7\x07\b\x02\x02" +
		"\xD7\'\x03\x02\x02\x02\xD8\xDA\x05*\x16\x02\xD9\xDB\x05,\x17\x02\xDA\xD9" +
		"\x03\x02\x02\x02\xDA\xDB\x03\x02\x02\x02\xDB\xDD\x03\x02\x02\x02\xDC\xDE" +
		"\x05.\x18\x02\xDD\xDC\x03\x02\x02\x02\xDD\xDE\x03\x02\x02\x02\xDE\xE0" +
		"\x03\x02\x02\x02\xDF\xE1\x050\x19\x02\xE0\xDF\x03\x02\x02\x02\xE0\xE1" +
		"\x03\x02\x02\x02\xE1\xE3\x03\x02\x02\x02\xE2\xE4\x052\x1A\x02\xE3\xE2" +
		"\x03\x02\x02\x02\xE4\xE5\x03\x02\x02\x02\xE5\xE3\x03\x02\x02\x02\xE5\xE6" +
		"\x03\x02\x02\x02\xE6)\x03\x02\x02\x02\xE7\xE8\x079\x02\x02\xE8\xE9\x07" +
		"P\x02\x02\xE9\xEE\x07:\x02\x02\xEA\xEC\x07Q\x02\x02\xEB\xED\x07\x07\x02" +
		"\x02\xEC\xEB\x03\x02\x02\x02\xEC\xED\x03\x02\x02\x02\xED\xEF\x03\x02\x02" +
		"\x02\xEE\xEA\x03\x02\x02\x02\xEF\xF0\x03\x02\x02\x02\xF0\xEE\x03\x02\x02" +
		"\x02\xF0\xF1\x03\x02\x02\x02\xF1\xF2\x03\x02\x02\x02\xF2\xF3\x07;\x02" +
		"\x02\xF3+\x03\x02\x02\x02\xF4\xF5\x07<\x02\x02\xF5\xF6\x07P\x02\x02\xF6" +
		"\xF7\x07N\x02\x02\xF7-\x03\x02\x02\x02\xF8\xF9\x07=\x02\x02\xF9\xFA\x07" +
		"P\x02\x02\xFA\xFB\x07N\x02\x02\xFB/\x03\x02\x02\x02\xFC\xFD\x07>\x02\x02" +
		"\xFD\xFE\x07P\x02\x02\xFE\xFF\x07N\x02\x02\xFF1\x03\x02\x02\x02\u0100" +
		"\u0101\x07?\x02\x02\u0101\u0102\x07Q\x02\x02\u0102\u0103\x05\n\x06\x02" +
		"\u0103\u0104\x054\x1B\x02\u01043\x03\x02\x02\x02\u0105\u0106\x056\x1C" +
		"\x02\u0106\u0107\x058\x1D\x02\u0107\u0108\x05B\"\x02\u01085\x03\x02\x02" +
		"\x02\u0109\u010A\x05:\x1E\x02\u010A\u010B\x05<\x1F\x02\u010B7\x03\x02" +
		"\x02\x02\u010C\u010D\x05> \x02\u010D\u010E\x05@!\x02\u010E9\x03\x02\x02" +
		"\x02\u010F\u0110\x07@\x02\x02\u0110\u0111\x05\n\x06\x02\u0111\u0116\x07" +
		"\x06\x02\x02\u0112\u0114\x07Q\x02\x02\u0113\u0115\x07\x07\x02\x02\u0114" +
		"\u0113\x03\x02\x02\x02\u0114\u0115\x03\x02\x02\x02\u0115\u0117\x03\x02" +
		"\x02\x02\u0116\u0112\x03\x02\x02\x02\u0117\u0118\x03\x02\x02\x02\u0118" +
		"\u0116\x03\x02\x02\x02\u0118\u0119\x03\x02\x02\x02\u0119\u011A\x03\x02" +
		"\x02\x02\u011A\u011B\x07\b\x02\x02\u011B;\x03\x02\x02\x02\u011C\u011D" +
		"\x07A\x02\x02\u011D\u011E\x05\n\x06\x02\u011E\u0123\x07\x06\x02\x02\u011F" +
		"\u0121\x05\x16\f\x02\u0120\u0122\x07\x07\x02\x02\u0121\u0120\x03\x02\x02" +
		"\x02\u0121\u0122\x03\x02\x02\x02\u0122\u0124\x03\x02\x02\x02\u0123\u011F" +
		"\x03\x02\x02\x02\u0124\u0125\x03\x02\x02\x02\u0125\u0123\x03\x02\x02\x02" +
		"\u0125\u0126\x03\x02\x02\x02\u0126\u0127\x03\x02\x02\x02\u0127\u0128\x07" +
		"\b\x02\x02\u0128=\x03\x02\x02\x02\u0129\u012A\x07\x05\x02\x02\u012A\u012B" +
		"\x05\n\x06\x02\u012B\u0130\x07\x06\x02\x02\u012C\u012E\x07Q\x02\x02\u012D" +
		"\u012F\x07\x07\x02\x02\u012E\u012D\x03\x02\x02\x02\u012E\u012F\x03\x02" +
		"\x02\x02\u012F\u0131\x03\x02\x02\x02\u0130\u012C\x03\x02\x02\x02\u0131" +
		"\u0132\x03\x02\x02\x02\u0132\u0130\x03\x02\x02\x02\u0132\u0133\x03\x02" +
		"\x02\x02\u0133\u0134\x03\x02\x02\x02\u0134\u0135\x07\b\x02\x02\u0135?" +
		"\x03\x02\x02\x02\u0136\u0137\x07B\x02\x02\u0137\u0138\x05\n\x06\x02\u0138" +
		"\u013D\x07\x06\x02\x02\u0139\u013B\x05\x16\f\x02\u013A\u013C\x07\x07\x02" +
		"\x02\u013B\u013A\x03\x02\x02\x02\u013B\u013C\x03\x02\x02\x02\u013C\u013E" +
		"\x03\x02\x02\x02\u013D\u0139\x03\x02\x02\x02\u013E\u013F\x03\x02\x02\x02" +
		"\u013F\u013D\x03\x02\x02\x02\u013F\u0140\x03\x02\x02\x02\u0140\u0141\x03" +
		"\x02\x02\x02\u0141\u0142\x07\b\x02\x02\u0142A\x03\x02\x02\x02\u0143\u0144" +
		"\x07C\x02\x02\u0144\u014F\x05\n\x06\x02\u0145\u0147\x05\x16\f\x02\u0146" +
		"\u0148\t\x07\x02\x02\u0147\u0146\x03\x02\x02\x02\u0147\u0148\x03\x02\x02" +
		"\x02\u0148\u014A\x03\x02\x02\x02\u0149\u0145\x03\x02\x02\x02\u014A\u014B" +
		"\x03\x02\x02\x02\u014B\u0149\x03\x02\x02\x02\u014B\u014C\x03\x02\x02\x02" +
		"\u014C\u014D\x03\x02\x02\x02\u014D\u014E\x07F\x02\x02\u014E\u0150\x03" +
		"\x02\x02\x02\u014F\u0149\x03\x02\x02\x02\u0150\u0151\x03\x02\x02\x02\u0151" +
		"\u014F\x03\x02\x02\x02\u0151\u0152\x03\x02\x02\x02\u0152C\x03\x02\x02" +
		"\x02\u0153\u0154\x07Q\x02\x02\u0154E\x03\x02\x02\x02&JSZajqw\x82\x86\x8A" +
		"\x90\x95\x9F\xAA\xAE\xB5\xB9\xBC\xC4\xDA\xDD\xE0\xE5\xEC\xF0\u0114\u0118" +
		"\u0121\u0125\u012E\u0132\u013B\u013F\u0147\u014B\u0151";
	public static __ATN: ATN;
	public static get _ATN(): ATN {
		if (!tsl_MRParser.__ATN) {
			tsl_MRParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(tsl_MRParser._serializedATN));
		}

		return tsl_MRParser.__ATN;
	}

}

export class TslContext extends ParserRuleContext {
	public parametersStatement(): ParametersStatementContext {
		return this.getRuleContext(0, ParametersStatementContext);
	}
	public environmentStatement(): EnvironmentStatementContext {
		return this.getRuleContext(0, EnvironmentStatementContext);
	}
	public outputStatement(): OutputStatementContext {
		return this.getRuleContext(0, OutputStatementContext);
	}
	public EOF(): TerminalNode { return this.getToken(tsl_MRParser.EOF, 0); }
	public mrStat(): MrStatContext | undefined {
		return this.tryGetRuleContext(0, MrStatContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_tsl; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterTsl) {
			listener.enterTsl(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitTsl) {
			listener.exitTsl(this);
		}
	}
}


export class ParametersStatementContext extends ParserRuleContext {
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public paragraphStatement(): ParagraphStatementContext[];
	public paragraphStatement(i: number): ParagraphStatementContext;
	public paragraphStatement(i?: number): ParagraphStatementContext | ParagraphStatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ParagraphStatementContext);
		} else {
			return this.getRuleContext(i, ParagraphStatementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_parametersStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterParametersStatement) {
			listener.enterParametersStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitParametersStatement) {
			listener.exitParametersStatement(this);
		}
	}
}


export class EnvironmentStatementContext extends ParserRuleContext {
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public paragraphStatement(): ParagraphStatementContext[];
	public paragraphStatement(i: number): ParagraphStatementContext;
	public paragraphStatement(i?: number): ParagraphStatementContext | ParagraphStatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ParagraphStatementContext);
		} else {
			return this.getRuleContext(i, ParagraphStatementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_environmentStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterEnvironmentStatement) {
			listener.enterEnvironmentStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitEnvironmentStatement) {
			listener.exitEnvironmentStatement(this);
		}
	}
}


export class OutputStatementContext extends ParserRuleContext {
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public outparagraphStatement(): OutparagraphStatementContext[];
	public outparagraphStatement(i: number): OutparagraphStatementContext;
	public outparagraphStatement(i?: number): OutparagraphStatementContext | OutparagraphStatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(OutparagraphStatementContext);
		} else {
			return this.getRuleContext(i, OutparagraphStatementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_outputStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterOutputStatement) {
			listener.enterOutputStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitOutputStatement) {
			listener.exitOutputStatement(this);
		}
	}
}


export class ColonContext extends ParserRuleContext {
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_colon; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterColon) {
			listener.enterColon(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitColon) {
			listener.exitColon(this);
		}
	}
}


export class ParagraphStatementContext extends ParserRuleContext {
	public NAME(): TerminalNode { return this.getToken(tsl_MRParser.NAME, 0); }
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public lineStatement(): LineStatementContext[];
	public lineStatement(i: number): LineStatementContext;
	public lineStatement(i?: number): LineStatementContext | LineStatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(LineStatementContext);
		} else {
			return this.getRuleContext(i, LineStatementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_paragraphStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterParagraphStatement) {
			listener.enterParagraphStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitParagraphStatement) {
			listener.exitParagraphStatement(this);
		}
	}
}


export class OutparagraphStatementContext extends ParserRuleContext {
	public NAME(): TerminalNode { return this.getToken(tsl_MRParser.NAME, 0); }
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public lineStatement(): LineStatementContext[];
	public lineStatement(i: number): LineStatementContext;
	public lineStatement(i?: number): LineStatementContext | LineStatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(LineStatementContext);
		} else {
			return this.getRuleContext(i, LineStatementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_outparagraphStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterOutparagraphStatement) {
			listener.enterOutparagraphStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitOutparagraphStatement) {
			listener.exitOutparagraphStatement(this);
		}
	}
}


export class LineStatementContext extends ParserRuleContext {
	public variant(): VariantContext {
		return this.getRuleContext(0, VariantContext);
	}
	public constraint(): ConstraintContext[];
	public constraint(i: number): ConstraintContext;
	public constraint(i?: number): ConstraintContext | ConstraintContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ConstraintContext);
		} else {
			return this.getRuleContext(i, ConstraintContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_lineStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterLineStatement) {
			listener.enterLineStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitLineStatement) {
			listener.exitLineStatement(this);
		}
	}
}


export class VariantContext extends ParserRuleContext {
	public dataTypes(): DataTypesContext {
		return this.getRuleContext(0, DataTypesContext);
	}
	public compare(): CompareContext[];
	public compare(i: number): CompareContext;
	public compare(i?: number): CompareContext | CompareContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CompareContext);
		} else {
			return this.getRuleContext(i, CompareContext);
		}
	}
	public NAME(): TerminalNode | undefined { return this.tryGetToken(tsl_MRParser.NAME, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_variant; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterVariant) {
			listener.enterVariant(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitVariant) {
			listener.exitVariant(this);
		}
	}
}


export class DataTypesContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_dataTypes; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterDataTypes) {
			listener.enterDataTypes(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitDataTypes) {
			listener.exitDataTypes(this);
		}
	}
}


export class CompareContext extends ParserRuleContext {
	public NAME(): TerminalNode { return this.getToken(tsl_MRParser.NAME, 0); }
	public comparisonOperator(): ComparisonOperatorContext | undefined {
		return this.tryGetRuleContext(0, ComparisonOperatorContext);
	}
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_compare; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterCompare) {
			listener.enterCompare(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitCompare) {
			listener.exitCompare(this);
		}
	}
}


export class ComparisonOperatorContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_comparisonOperator; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterComparisonOperator) {
			listener.enterComparisonOperator(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitComparisonOperator) {
			listener.exitComparisonOperator(this);
		}
	}
}


export class ExpressionContext extends ParserRuleContext {
	public NUMBER(): TerminalNode[];
	public NUMBER(i: number): TerminalNode;
	public NUMBER(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(tsl_MRParser.NUMBER);
		} else {
			return this.getToken(tsl_MRParser.NUMBER, i);
		}
	}
	public NAME(): TerminalNode[];
	public NAME(i: number): TerminalNode;
	public NAME(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(tsl_MRParser.NAME);
		} else {
			return this.getToken(tsl_MRParser.NAME, i);
		}
	}
	public exp(): ExpContext[];
	public exp(i: number): ExpContext;
	public exp(i?: number): ExpContext | ExpContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpContext);
		} else {
			return this.getRuleContext(i, ExpContext);
		}
	}
	public MIN(): TerminalNode | undefined { return this.tryGetToken(tsl_MRParser.MIN, 0); }
	public MAX(): TerminalNode | undefined { return this.tryGetToken(tsl_MRParser.MAX, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_expression; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterExpression) {
			listener.enterExpression(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitExpression) {
			listener.exitExpression(this);
		}
	}
}


export class ExpContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_exp; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterExp) {
			listener.enterExp(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitExp) {
			listener.exitExp(this);
		}
	}
}


export class ConstraintContext extends ParserRuleContext {
	public ifStatement(): IfStatementContext | undefined {
		return this.tryGetRuleContext(0, IfStatementContext);
	}
	public propertyStatement(): PropertyStatementContext | undefined {
		return this.tryGetRuleContext(0, PropertyStatementContext);
	}
	public errorStatement(): ErrorStatementContext | undefined {
		return this.tryGetRuleContext(0, ErrorStatementContext);
	}
	public singleStatement(): SingleStatementContext | undefined {
		return this.tryGetRuleContext(0, SingleStatementContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_constraint; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterConstraint) {
			listener.enterConstraint(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitConstraint) {
			listener.exitConstraint(this);
		}
	}
}


export class IfStatementContext extends ParserRuleContext {
	public NAME(): TerminalNode { return this.getToken(tsl_MRParser.NAME, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_ifStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterIfStatement) {
			listener.enterIfStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitIfStatement) {
			listener.exitIfStatement(this);
		}
	}
}


export class PropertyStatementContext extends ParserRuleContext {
	public NAME(): TerminalNode { return this.getToken(tsl_MRParser.NAME, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_propertyStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterPropertyStatement) {
			listener.enterPropertyStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitPropertyStatement) {
			listener.exitPropertyStatement(this);
		}
	}
}


export class ErrorStatementContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_errorStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterErrorStatement) {
			listener.enterErrorStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitErrorStatement) {
			listener.exitErrorStatement(this);
		}
	}
}


export class SingleStatementContext extends ParserRuleContext {
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_singleStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterSingleStatement) {
			listener.enterSingleStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitSingleStatement) {
			listener.exitSingleStatement(this);
		}
	}
}


export class MrStatContext extends ParserRuleContext {
	public spec(): SpecContext {
		return this.getRuleContext(0, SpecContext);
	}
	public iteNumbers(): IteNumbersContext | undefined {
		return this.tryGetRuleContext(0, IteNumbersContext);
	}
	public iteSuite(): IteSuiteContext | undefined {
		return this.tryGetRuleContext(0, IteSuiteContext);
	}
	public iteRate(): IteRateContext | undefined {
		return this.tryGetRuleContext(0, IteRateContext);
	}
	public mrStatement(): MrStatementContext[];
	public mrStatement(i: number): MrStatementContext;
	public mrStatement(i?: number): MrStatementContext | MrStatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(MrStatementContext);
		} else {
			return this.getRuleContext(i, MrStatementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_mrStat; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterMrStat) {
			listener.enterMrStat(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitMrStat) {
			listener.exitMrStat(this);
		}
	}
}


export class SpecContext extends ParserRuleContext {
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public NAME(): TerminalNode[];
	public NAME(i: number): TerminalNode;
	public NAME(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(tsl_MRParser.NAME);
		} else {
			return this.getToken(tsl_MRParser.NAME, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_spec; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterSpec) {
			listener.enterSpec(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitSpec) {
			listener.exitSpec(this);
		}
	}
}


export class IteNumbersContext extends ParserRuleContext {
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public NUMBER(): TerminalNode { return this.getToken(tsl_MRParser.NUMBER, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_iteNumbers; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterIteNumbers) {
			listener.enterIteNumbers(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitIteNumbers) {
			listener.exitIteNumbers(this);
		}
	}
}


export class IteSuiteContext extends ParserRuleContext {
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public NUMBER(): TerminalNode { return this.getToken(tsl_MRParser.NUMBER, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_iteSuite; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterIteSuite) {
			listener.enterIteSuite(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitIteSuite) {
			listener.exitIteSuite(this);
		}
	}
}


export class IteRateContext extends ParserRuleContext {
	public COLON(): TerminalNode { return this.getToken(tsl_MRParser.COLON, 0); }
	public NUMBER(): TerminalNode { return this.getToken(tsl_MRParser.NUMBER, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_iteRate; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterIteRate) {
			listener.enterIteRate(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitIteRate) {
			listener.exitIteRate(this);
		}
	}
}


export class MrStatementContext extends ParserRuleContext {
	public NAME(): TerminalNode { return this.getToken(tsl_MRParser.NAME, 0); }
	public colon(): ColonContext {
		return this.getRuleContext(0, ColonContext);
	}
	public mr(): MrContext {
		return this.getRuleContext(0, MrContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_mrStatement; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterMrStatement) {
			listener.enterMrStatement(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitMrStatement) {
			listener.exitMrStatement(this);
		}
	}
}


export class MrContext extends ParserRuleContext {
	public input(): InputContext {
		return this.getRuleContext(0, InputContext);
	}
	public output(): OutputContext {
		return this.getRuleContext(0, OutputContext);
	}
	public relation(): RelationContext {
		return this.getRuleContext(0, RelationContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_mr; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterMr) {
			listener.enterMr(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitMr) {
			listener.exitMr(this);
		}
	}
}


export class InputContext extends ParserRuleContext {
	public in(): InContext {
		return this.getRuleContext(0, InContext);
	}
	public inFollow(): InFollowContext {
		return this.getRuleContext(0, InFollowContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_input; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterInput) {
			listener.enterInput(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitInput) {
			listener.exitInput(this);
		}
	}
}


export class OutputContext extends ParserRuleContext {
	public out(): OutContext {
		return this.getRuleContext(0, OutContext);
	}
	public outFollow(): OutFollowContext {
		return this.getRuleContext(0, OutFollowContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_output; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterOutput) {
			listener.enterOutput(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitOutput) {
			listener.exitOutput(this);
		}
	}
}


export class InContext extends ParserRuleContext {
	public colon(): ColonContext {
		return this.getRuleContext(0, ColonContext);
	}
	public NAME(): TerminalNode[];
	public NAME(i: number): TerminalNode;
	public NAME(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(tsl_MRParser.NAME);
		} else {
			return this.getToken(tsl_MRParser.NAME, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_in; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterIn) {
			listener.enterIn(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitIn) {
			listener.exitIn(this);
		}
	}
}


export class InFollowContext extends ParserRuleContext {
	public colon(): ColonContext {
		return this.getRuleContext(0, ColonContext);
	}
	public compare(): CompareContext[];
	public compare(i: number): CompareContext;
	public compare(i?: number): CompareContext | CompareContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CompareContext);
		} else {
			return this.getRuleContext(i, CompareContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_inFollow; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterInFollow) {
			listener.enterInFollow(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitInFollow) {
			listener.exitInFollow(this);
		}
	}
}


export class OutContext extends ParserRuleContext {
	public colon(): ColonContext {
		return this.getRuleContext(0, ColonContext);
	}
	public NAME(): TerminalNode[];
	public NAME(i: number): TerminalNode;
	public NAME(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(tsl_MRParser.NAME);
		} else {
			return this.getToken(tsl_MRParser.NAME, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_out; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterOut) {
			listener.enterOut(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitOut) {
			listener.exitOut(this);
		}
	}
}


export class OutFollowContext extends ParserRuleContext {
	public colon(): ColonContext {
		return this.getRuleContext(0, ColonContext);
	}
	public compare(): CompareContext[];
	public compare(i: number): CompareContext;
	public compare(i?: number): CompareContext | CompareContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CompareContext);
		} else {
			return this.getRuleContext(i, CompareContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_outFollow; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterOutFollow) {
			listener.enterOutFollow(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitOutFollow) {
			listener.exitOutFollow(this);
		}
	}
}


export class RelationContext extends ParserRuleContext {
	public colon(): ColonContext {
		return this.getRuleContext(0, ColonContext);
	}
	public compare(): CompareContext[];
	public compare(i: number): CompareContext;
	public compare(i?: number): CompareContext | CompareContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CompareContext);
		} else {
			return this.getRuleContext(i, CompareContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_relation; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterRelation) {
			listener.enterRelation(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitRelation) {
			listener.exitRelation(this);
		}
	}
}


export class Encoding_declContext extends ParserRuleContext {
	public NAME(): TerminalNode { return this.getToken(tsl_MRParser.NAME, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return tsl_MRParser.RULE_encoding_decl; }
	// @Override
	public enterRule(listener: tsl_MRListener): void {
		if (listener.enterEncoding_decl) {
			listener.enterEncoding_decl(this);
		}
	}
	// @Override
	public exitRule(listener: tsl_MRListener): void {
		if (listener.exitEncoding_decl) {
			listener.exitEncoding_decl(this);
		}
	}
}


